﻿using System;
using System.Collections.Generic;
using System.Text;

namespace HolisticWare.VoIP.Getafisk.DLL_02BL_netfx35.any_any_any
{
	[Serializable]
	public 
		class 
		Trunk
	{

		# region ---- Property string Name --------------------
		private string _Name;

		public string Name
		{
			get { return _Name; }
			set
			{
				if (value != _Name)
				{
					// lock(_Name) // MultiThread safe
					{
						_Name = value;
						if (null != NameChanged)
							NameChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler NameChanged;
		# endregion ---- string Property.Name --------------------

		# region ---- Property ProtocolType Protocol --------------------
		private ProtocolType _Protocol;

		public ProtocolType Protocol
		{
			get { return _Protocol; }
			set
			{
				if (value != _Protocol)
				{
					// lock(_Protocol) // MultiThread safe
					{
						_Protocol = value;
						if (null != ProtocolChanged)
							ProtocolChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler ProtocolChanged;
		# endregion ---- ProtocolType Property.Protocol --------------------

		# region ---- Property int ChannelsMaximum --------------------
		private int _ChannelsMaximum;

		public int ChannelsMaximum
		{
			get { return _ChannelsMaximum; }
			set
			{
				if (value != _ChannelsMaximum)
				{
					// lock(_ChannelsMaximum) // MultiThread safe
					{
						_ChannelsMaximum = value;
						if (null != ChannelsMaximumChanged)
							ChannelsMaximumChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler ChannelsMaximumChanged;
		# endregion ---- int Property.ChannelsMaximum --------------------

		# region ---- Property string CallerIDOutbound --------------------
		private string _CallerIDOutbound;

		public string CallerIDOutbound
		{
			get { return _CallerIDOutbound; }
			set
			{
				if (value != _CallerIDOutbound)
				{
					// lock(_CallerIDOutbound) // MultiThread safe
					{
						_CallerIDOutbound = value;
						if (null != CallerIDOutboundChanged)
							CallerIDOutboundChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler CallerIDOutboundChanged;
		# endregion ---- string Property.CallerIDOutbound --------------------

		# region ---- Property bool Disabled --------------------
		private bool _Disabled;

		public bool Disabled
		{
			get { return _Disabled; }
			set
			{
				if (value != _Disabled)
				{
					// lock(_Disabled) // MultiThread safe
					{
						_Disabled = value;
						if (null != DisabledChanged)
							DisabledChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler DisabledChanged;
		# endregion ---- bool Property.Disabled --------------------

		# region ---- Property bool FailureMonitoring --------------------
		private bool _FailureMonitoring;

		public bool FailureMonitoring
		{
			get { return _FailureMonitoring; }
			set
			{
				if (value != _FailureMonitoring)
				{
					// lock(_FailureMonitoring) // MultiThread safe
					{
						_FailureMonitoring = value;
						if (null != FailureMonitoringChanged)
							FailureMonitoringChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler FailureMonitoringChanged;
		# endregion ---- bool Property.FailureMonitoring --------------------

		# region ---- Property string[] DialRules --------------------
		private string[] _DialRules;

		public string[] DialRules
		{
			get { return _DialRules; }
			set
			{
				if (value != _DialRules)
				{
					// lock(_DialRules) // MultiThread safe
					{
						_DialRules = value;
						if (null != DialRulesChanged)
							DialRulesChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler DialRulesChanged;
		# endregion ---- string[] Property.DialRules --------------------

		# region ---- Property string OutboundDialPrefix --------------------
		private string _OutboundDialPrefix;

		public string OutboundDialPrefix
		{
			get { return _OutboundDialPrefix; }
			set
			{
				if (value != _OutboundDialPrefix)
				{
					// lock(_OutboundDialPrefix) // MultiThread safe
					{
						_OutboundDialPrefix = value;
						if (null != OutboundDialPrefixChanged)
							OutboundDialPrefixChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler OutboundDialPrefixChanged;
		# endregion ---- string Property.OutboundDialPrefix --------------------

		# region ---- Property string[] PeerDetails --------------------
		private string[] _PeerDetails;

		public string[] PeerDetails
		{
			get { return _PeerDetails; }
			set
			{
				if (value != _PeerDetails)
				{
					// lock(_PeerDetails) // MultiThread safe
					{
						_PeerDetails = value;
						if (null != PeerDetailsChanged)
							PeerDetailsChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler PeerDetailsChanged;
		# endregion ---- string[] Property.PeerDetails --------------------

		# region ---- Property string ContextUser --------------------
		private string _ContextUser;

		public string ContextUser
		{
			get { return _ContextUser; }
			set
			{
				if (value != _ContextUser)
				{
					// lock(_ContextUser) // MultiThread safe
					{
						_ContextUser = value;
						if (null != ContextUserChanged)
							ContextUserChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler ContextUserChanged;
		# endregion ---- string Property.ContextUser --------------------

		# region ---- Property string[] ContextUserDetails --------------------
		private string[] _ContextUserDetails;

		public string[] ContextUserDetails
		{
			get { return _ContextUserDetails; }
			set
			{
				if (value != _ContextUserDetails)
				{
					// lock(_ContextUserDetails) // MultiThread safe
					{
						_ContextUserDetails = value;
						if (null != ContextUserDetailsChanged)
							ContextUserDetailsChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler ContextUserDetailsChanged;
		# endregion ---- string[] Property.ContextUserDetails --------------------

		# region ---- Property string RegisterString --------------------
		private string _RegisterString;

		public string RegisterString
		{
			get { return _RegisterString; }
			set
			{
				if (value != _RegisterString)
				{
					// lock(_RegisterString) // MultiThread safe
					{
						_RegisterString = value;
						if (null != RegisterStringChanged)
							RegisterStringChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler RegisterStringChanged;
		# endregion ---- string Property.RegisterString --------------------

		
		public
			Trunk
			(
			)
		{
			_Name = "";
			_Protocol = ProtocolType.SIP;

			return;
		}
	
	
	}
}
